import { storageSet, storageGet, storageRemove, isTauri } from './secure-storage';
import { API_BASE_URL } from '@/config/env';

export interface User {
  id: string;
  snowflake_id?: number | string; // 后端返回字符串，前端兼容数字和字符串
  open_id?: string; // 外部唯一标识符（类似微信open_id）
  name: string;
  email: string;
  file_name?: string; // 头像文件名
  abstract?: string; // 个性签名
  phone?: string; // 手机号
  status?: number; // 状态：1正常 2禁用 3删除
  gender?: number; // 性别：1男 2女 3未知
}

export interface LoginResponse {
  user: User;
  token: string;
  subscription_id: string;
}

export const login = async (username: string, password: string): Promise<LoginResponse> => {
  const response = await fetch(`${API_BASE_URL}/api/auth/login`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ username, password }),
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({ message: '登录失败' }));
    throw new Error(error.message || '登录失败');
  }

  const responseData = await response.json();
  
  // 将后端返回的字段映射到前端接口格式
  // 后端返回 abstract_field，前端使用 abstract
  const user: User = {
    ...responseData.user,
    id: String(responseData.user.id), // 确保 id 是字符串
    abstract: responseData.user.abstract_field || responseData.user.abstract, // 映射 abstract_field 到 abstract
  };
  
  const data: LoginResponse = {
    ...responseData,
    user,
  };
  
  // 获取旧用户的 open_id（用于清除旧缓存）
  const oldOpenId = isTauri()
    ? await storageGet('openId')
    : localStorage.getItem('openId');
  
  // 确保后端返回了 open_id（如果没有，使用 snowflake_id 或 id 作为后备）
  // 但前端统一使用 open_id 作为唯一标识
  const openId = user.open_id || 
                 (user.snowflake_id ? String(user.snowflake_id) : null) || 
                 user.id;
  
  if (!openId) {
    throw new Error('无法获取用户标识符，登录失败');
  }
  
  // 使用安全存储保存会话数据（只保存 open_id 作为用户唯一标识）
  if (isTauri()) {
    await storageSet('token', data.token);
    await storageSet('user', JSON.stringify(user));
    await storageSet('openId', openId);
    
    // 保存订阅 ID
    if (data.subscription_id) {
      await storageSet('subscriptionId', data.subscription_id);
    }
  } else {
    // 浏览器环境使用 localStorage（只保存 open_id 作为用户唯一标识）
    localStorage.setItem('token', data.token);
    localStorage.setItem('user', JSON.stringify(user));
    localStorage.setItem('openId', openId);
    
    if (data.subscription_id) {
      localStorage.setItem('subscriptionId', data.subscription_id);
    }
  }
  
  // 如果切换了用户，清除旧用户的好友列表和群组列表缓存
  if (oldOpenId && oldOpenId !== openId) {
    console.log('检测到用户切换，清除旧用户缓存和连接:', oldOpenId, '->', openId);
    // 先断开旧的 WebSocket 连接（如果存在）
    try {
      const { useChatStore } = await import('../stores/chat');
      const chatStore = useChatStore();
      if (chatStore.isConnected) {
        console.log('断开旧用户的 WebSocket 连接');
        await chatStore.disconnect(true); // 清空消息
      }
      // 清空当前聊天目标，避免显示旧用户的消息
      chatStore.setTarget('', 'User');
    } catch (e) {
      console.warn('断开旧连接失败（可能未连接）:', e);
    }
    
    const { clearFriendsCache } = await import('./im-friendship');
    const { clearGroupsCache } = await import('./im-group');
    await clearFriendsCache(oldOpenId);
    await clearGroupsCache(oldOpenId);
  }
  
  // 登录成功后，获取群组列表并保存到本地存储
  // 注意：这里等待保存完成，确保后续读取时能获取到数据
  // 注意：不再在登录时获取群组列表
  // 群组会从聊天记录中自动识别（2人=单聊，3人及以上=群组）
  
  return data;
};

export const register = async (name: string, email: string, password: string, phone?: string): Promise<User> => {
  const response = await fetch(`${API_BASE_URL}/api/auth/register`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ 
      name, 
      email, 
      password,
      ...(phone ? { phone } : {}),
    }),
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({ message: '注册失败' }));
    throw new Error(error.message || '注册失败');
  }

  const responseData = await response.json();
  
  // 将后端返回的字段映射到前端接口格式
  const user: User = {
    ...responseData,
    id: String(responseData.id), // 确保 id 是字符串
    abstract: responseData.abstract_field || responseData.abstract, // 映射 abstract_field 到 abstract
  };
  
  return user;
};

export const logout = async () => {
  // 获取当前用户的 open_id，用于清理用户相关的缓存
  const currentOpenId = isTauri()
    ? await storageGet('openId')
    : localStorage.getItem('openId');
  
  // 清理用户相关的缓存（好友列表、群组列表等）
  if (currentOpenId) {
    try {
      const { clearFriendsCache } = await import('./im-friendship');
      const { clearGroupsCache } = await import('./im-group');
      await clearFriendsCache(currentOpenId);
      await clearGroupsCache(currentOpenId);
    } catch (e) {
      console.warn('清理用户缓存失败:', e);
    }
  }
  
  // 清理所有会话数据（只保留 open_id 相关的清理）
  if (isTauri()) {
    await storageRemove('token');
    await storageRemove('user');
    await storageRemove('openId');
    await storageRemove('subscriptionId');
    // 清理可能存在的旧字段（兼容性清理）
    await storageRemove('userId').catch(() => {});
    await storageRemove('snowflakeId').catch(() => {});
  } else {
    localStorage.removeItem('token');
    localStorage.removeItem('user');
    localStorage.removeItem('openId');
    localStorage.removeItem('subscriptionId');
    // 清理可能存在的旧字段（兼容性清理）
    localStorage.removeItem('userId');
    localStorage.removeItem('snowflakeId');
  }
  
  console.log('用户已登出，所有会话数据已清理');
};

// 同步版本（用于快速检查，使用 localStorage 缓存）
export const isAuthenticated = (): boolean => {
  return !!localStorage.getItem('token');
};

// 异步版本（用于准确检查，使用安全存储）
export const isAuthenticatedAsync = async (): Promise<boolean> => {
  if (isTauri()) {
    const token = await storageGet('token');
    return !!token;
  } else {
    return !!localStorage.getItem('token');
  }
};

// 同步版本（用于快速读取，使用 localStorage 缓存）
export const getUser = (): User | null => {
  const userStr = localStorage.getItem('user');
  if (userStr) {
    try {
      return JSON.parse(userStr);
    } catch {
      return null;
    }
  }
  return null;
};

// 异步版本（用于准确读取，使用安全存储）
export const getUserAsync = async (): Promise<User | null> => {
  let userStr: string | null = null;
  
  if (isTauri()) {
    userStr = await storageGet('user');
  } else {
    userStr = localStorage.getItem('user');
  }
  
  if (userStr) {
    try {
      return JSON.parse(userStr);
    } catch {
      return null;
    }
  }
  return null;
};

export interface UpdateUserProfileReq {
  name?: string;
  file_name?: string | null;
  abstract_field?: string | null;
  phone?: string | null;
  gender?: number;
}

export const updateUserProfile = async (data: UpdateUserProfileReq): Promise<User> => {
  const token = localStorage.getItem('token');
  if (!token) {
    throw new Error('请先登录');
  }

  const response = await fetch(`${API_BASE_URL}/api/users/me`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`,
    },
    body: JSON.stringify(data),
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({ message: '更新失败' }));
    throw new Error(error.message || '更新失败');
  }

  const responseData = await response.json();
  
  // 将后端返回的字段映射到前端接口格式
  // 后端返回 abstract_field，前端使用 abstract
  const updatedUser: User = {
    ...responseData,
    id: String(responseData.id), // 确保 id 是字符串
    abstract: responseData.abstract_field || responseData.abstract, // 映射 abstract_field 到 abstract
  };
  
  // 更新本地存储（确保 open_id 存在）
  const openId = updatedUser.open_id || 
                 (updatedUser.snowflake_id ? String(updatedUser.snowflake_id) : null) || 
                 updatedUser.id;
  
  if (isTauri()) {
    await storageSet('user', JSON.stringify(updatedUser));
    await storageSet('openId', openId);
  } else {
    localStorage.setItem('user', JSON.stringify(updatedUser));
    localStorage.setItem('openId', openId);
  }

  return updatedUser;
};

